package com.itjin.service.impl;

import com.aliyun.oss.OSS;
import com.aliyun.oss.model.PutObjectRequest;
import com.itjin.model.domain.vo.BeautifiedContentVO;
import com.itjin.service.CommonService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.web.client.RestTemplate;

import jakarta.annotation.Resource;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

@Service
@Slf4j
public class CommonServiceImpl implements CommonService {

  @Resource
  private OSS ossClient;

  @Resource
  private RestTemplate restTemplate;

  @Value("${alibaba.cloud.oss.bucket-name}")
  private String bucketName;

  @Value("${alibaba.cloud.oss.endpoint}")
  private String endpoint;

  private static final String SHISA_AI_API_URL = "https://openrouter.ai/api/v1/chat/completions";
  private static final String SHISA_AI_API_KEY = "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";
  private static final String SHISA_AI_MODEL = "shisa-ai/shisa-v2-llama3.3-70b:free";
  private static final String SITE_URL = "https://yourapplication.com";
  private static final String SITE_NAME = "User Center Application";

  @Override
  public String uploadFile(MultipartFile file) throws Exception {
    try {
      // 生成文件名
      String originalFilename = file.getOriginalFilename();
      String suffix = originalFilename.substring(originalFilename.lastIndexOf("."));
      String fileName = "avatar/" + UUID.randomUUID().toString().replaceAll("-", "") + suffix;

      // 创建PutObjectRequest对象
      PutObjectRequest putObjectRequest = new PutObjectRequest(bucketName, fileName, file.getInputStream());

      // 上传文件
      ossClient.putObject(putObjectRequest);

      // 生成文件访问路径
      return "https://" + bucketName + "." + endpoint + "/" + fileName;
    } catch (Exception e) {
      log.error("文件上传失败", e);
      throw new RuntimeException("文件上传失败: " + e.getMessage());
    }
  }

  @Override
  public String uploadFileGeneral(MultipartFile file, String folder) throws Exception {
    try {
      // 验证文件夹路径
      if (folder == null || folder.trim().isEmpty()) {
        folder = "general";
      }
      
      // 确保文件夹路径以 / 结尾
      if (!folder.endsWith("/")) {
        folder = folder + "/";
      }

      // 生成文件名
      String originalFilename = file.getOriginalFilename();
      String suffix = "";
      if (originalFilename != null && originalFilename.contains(".")) {
        suffix = originalFilename.substring(originalFilename.lastIndexOf("."));
      }
      
      String fileName = folder + UUID.randomUUID().toString().replaceAll("-", "") + suffix;

      // 创建PutObjectRequest对象
      PutObjectRequest putObjectRequest = new PutObjectRequest(bucketName, fileName, file.getInputStream());

      // 上传文件
      ossClient.putObject(putObjectRequest);

      // 生成文件访问路径
      return "https://" + bucketName + "." + endpoint + "/" + fileName;
    } catch (Exception e) {
      log.error("通用文件上传失败", e);
      throw new RuntimeException("通用文件上传失败: " + e.getMessage());
    }
  }

  @Override
  public BeautifiedContentVO beautifyPostContent(String content) throws Exception {
    if (content == null || content.trim().isEmpty()) {
      return BeautifiedContentVO.builder()
          .originalContent(content)
          .beautifiedContent(content)
          .isBeautified(false)
          .build();
    }

    try {
      // 创建HTTP请求头
      HttpHeaders headers = new HttpHeaders();
      headers.setContentType(MediaType.APPLICATION_JSON);
      headers.set("Authorization", "Bearer " + SHISA_AI_API_KEY);
      headers.set("HTTP-Referer", SITE_URL);
      headers.set("X-Title", SITE_NAME);

      // 创建一个更好的提示词
      String promptTemplate = "你是一位能深入理解人类情感和心理的内容创作者，请帮我改写以下帖子内容。" +
          "**核心要求：内容改写必须精简，不要过度扩展原文，保持大致相同长度**\n\n" +
          "**第一步：分析**\n" +
          "首先，请分析帖子作者的潜在情感和意图：\n" +
          "- 他们的心情是什么？（开心、担忧、困惑、愤怒、期待等）\n" +
          "- 他们的目的是什么？（分享经历、寻求帮助、发泄情绪、提出建议等）\n" +
          "- 他们关心的核心问题是什么？\n\n" +

          "**第二步：改写**\n" +
          "根据你的分析，改写内容，要求：\n" +
          "1. 严格保持原文的核心意思和目的\n" +
          "2. 使用更生动、更有共鸣的表达方式\n" +
          "3. 加入适当的口语化表达和语气词，如「啊」「呢」「吧」等，使内容更自然\n" +
          "4. 根据情感类型调整语气\n" +
          "5. 语言风格应该像一个真实的人在社交平台上发帖，有个性但不做作\n" +
          "6. 避免过于正式或官方的表达方式\n" +
          "7. 保持简洁自然，必须与原文长度接近\n" +
          "8. 不要添加原文中没有的具体信息、事件或细节\n\n" +

          "**绝对禁止事项：**\n" +
          "- 不要添加任何类型的引号，包括英文引号、中文引号等\n" +
          "- 不要大幅扩展内容，保持与原文相似的长度\n" +
          "- 不要添加原文中没有提及的活动、人物或事件\n" +
          "- 不要添加感叹号等过度情绪化的标点符号\n" +
          "- 不要在输出中包含任何分析内容\n" +
          "- 不要使用任何Markdown或HTML标记\n" +
          "- 不要在输出中使用任何代码格式或特殊字符\n" +
          "- 只使用中文，不要加入任何其他语言的单词\n" +
          "- 不要添加表情符号\n\n" +

          "原始内容：\n" + content;

      // 如果内容很短，使用更严格的提示词，防止过度扩展
      if (content.length() < 30) {
        promptTemplate = "你需要对以下短文本进行轻微改写，使其更自然流畅，但必须遵循以下规则：\n" +
            "1. 保持原文长度，不要扩展内容\n" +
            "2. 不要添加任何原文没有的信息或细节\n" +
            "3. 不要使用任何类型的引号或特殊符号\n" +
            "4. 不要添加感叹号等额外标点\n" +
            "5. 只是稍微改变语序或用词，让表达更自然\n" +
            "6. 如果原文有错别字，可以修正\n\n" +
            "原文：" + content + "\n\n" +
            "请直接给出修改后的内容，不要添加任何解释或额外文字。";
      }

      // 创建消息体
      Map<String, Object> message = new HashMap<>();
      message.put("role", "user");
      message.put("content", promptTemplate);

      List<Map<String, Object>> messages = new ArrayList<>();
      messages.add(message);

      // 创建请求体
      Map<String, Object> requestBody = new HashMap<>();
      requestBody.put("model", SHISA_AI_MODEL);
      requestBody.put("messages", messages);
      requestBody.put("max_tokens", 1024);
      requestBody.put("temperature", 0.7); // 添加温度参数，控制创造性

      // 发送请求
      HttpEntity<Map<String, Object>> entity = new HttpEntity<>(requestBody, headers);
      Map<String, Object> response = restTemplate.postForObject(SHISA_AI_API_URL, entity, Map.class);

      // 解析响应
      if (response != null && response.containsKey("choices")) {
        List<Map<String, Object>> choices = (List<Map<String, Object>>) response.get("choices");
        if (!choices.isEmpty()) {
          Map<String, Object> choice = choices.get(0);
          Map<String, Object> message_response = (Map<String, Object>) choice.get("message");
          if (message_response != null && message_response.containsKey("content")) {
            String beautified = (String) message_response.get("content");

            // 清理可能的残余格式标记和非中文内容
            beautified = cleanBeautifiedContent(beautified);

            // 验证美化内容的质量和长度
            boolean isContentValid = isValidBeautifiedContent(beautified);
            boolean isLengthValid = isLengthReasonable(content, beautified);

            if (isContentValid && isLengthValid) {
              return BeautifiedContentVO.builder()
                  .originalContent(content)
                  .beautifiedContent(beautified)
                  .isBeautified(true)
                  .build();
            } else if (isContentValid) {
              // 内容有效但长度不合理，可能添加了太多内容
              log.warn("AI美化内容长度不合理，原长度: {}, 美化后长度: {}", content.length(), beautified.length());
            }
          }
        }
      }

      log.warn("AI美化内容响应格式异常或内容质量不合格: {}", response);
      return BeautifiedContentVO.builder()
          .originalContent(content)
          .beautifiedContent(content)
          .isBeautified(false)
          .build();
    } catch (Exception e) {
      log.error("AI美化帖子内容失败", e);
      // 如果AI调用失败，返回原始内容
      return BeautifiedContentVO.builder()
          .originalContent(content)
          .beautifiedContent(content)
          .isBeautified(false)
          .build();
    }
  }

  /**
   * 清理美化后的内容，移除不需要的元素
   */
  private String cleanBeautifiedContent(String content) {
    if (content == null)
      return "";

    // 检查是否包含分析步骤（如果包含应该移除）
    String cleaned = content;
    if (cleaned.contains("分析：") || cleaned.contains("第一步：") || cleaned.contains("第二步：")) {
      // 尝试找到最后一个明显的分隔点，通常是改写结果的开始
      int lastSeparatorIndex = -1;
      String[] possibleSeparators = { "改写结果：", "最终内容：", "修改后的内容：", "修改后：", "改写后：" };

      for (String separator : possibleSeparators) {
        int index = cleaned.lastIndexOf(separator);
        if (index > lastSeparatorIndex) {
          lastSeparatorIndex = index;
        }
      }

      if (lastSeparatorIndex > 0) {
        // 找到分隔符，截取之后的内容
        cleaned = cleaned.substring(lastSeparatorIndex);
        // 再去除分隔符本身
        for (String separator : possibleSeparators) {
          cleaned = cleaned.replaceFirst(separator, "");
        }
      }
    }

    // 移除内容首尾的各种类型引号
    cleaned = cleaned.trim();

    // 先移除可能的首尾引号
    if (cleaned.length() >= 2) {
      // 检查首尾是否为引号
      char firstChar = cleaned.charAt(0);
      char lastChar = cleaned.charAt(cleaned.length() - 1);

      // 判断常见的首尾引号对
      if ((firstChar == '\"' && lastChar == '\"') ||
          (firstChar == '\'' && lastChar == '\'') ||
          (firstChar == '「' && lastChar == '」') ||
          (firstChar == '『' && lastChar == '』') ||
          (firstChar == '【' && lastChar == '】') ||
          (firstChar == '《' && lastChar == '》')) {
        cleaned = cleaned.substring(1, cleaned.length() - 1);
      }
    }

    // 移除内容中的所有引号字符
    cleaned = cleaned.replace("\"", "").replace("'", "")
        .replace("\u201C", "").replace("\u201D", "") // 中文双引号
        .replace("\u2018", "").replace("\u2019", "") // 中文单引号
        .replace("\u300C", "").replace("\u300D", "") // 中文书名号「」
        .replace("\u300E", "").replace("\u300F", "") // 中文书名号『』
        .replace("\u3010", "").replace("\u3011", "") // 中文方括号【】
        .replace("\u300A", "").replace("\u300B", ""); // 中文书名号《》

    // 移除内容中不必要的转义字符
    cleaned = cleaned.replace("\\\"", "").replace("\\n", "\n").replace("\\t", "\t");

    // 移除Markdown标记
    cleaned = cleaned.replaceAll("\\*\\*", "");

    // 移除可能的多余版本标记
    cleaned = cleaned.replaceAll("(?i)(最终版本|最终简洁版|优化后.*版本|清晰表达后.*版本|建议最终.*方案).*", "");

    // 移除非中文内容块
    cleaned = cleaned.replaceAll("[a-zA-Z0-9_\\-\\.]+\\(.*?\\)", "");

    // 移除技术术语和代码片段
    cleaned = cleaned.replaceAll("\\b[a-zA-Z_][a-zA-Z0-9_]*\\.[a-zA-Z_][a-zA-Z0-9_]*\\b", "");

    // 移除奇怪的符号和编程语言关键字
    cleaned = cleaned.replaceAll("\\b(var|let|const|function|class|if|else|for|while|return|import|export)\\b", "");

    // 移除多余的符号
    cleaned = cleaned.replaceAll("[\\{\\}\\[\\]\\|\\\\]+", "");

    // 减少过多的感叹号（如果有连续的感叹号，只保留一个）
    cleaned = cleaned.replaceAll("！{2,}", "！").replaceAll("!{2,}", "!");

    // 移除包含非中文字符的单词(保留中文标点符号和空白字符)
    cleaned = cleaned.replaceAll("(?<![\\u4e00-\\u9fa5])[a-zA-Z0-9_]+(?![\\u4e00-\\u9fa5])", "");

    // 移除连续多个空格和空行
    cleaned = cleaned.replaceAll("\\s{2,}", " ").replaceAll("\\n{2,}", "\n");

    return cleaned.trim();
  }

  /**
   * 验证美化后的内容是否符合质量要求
   */
  private boolean isValidBeautifiedContent(String content) {
    if (content == null || content.trim().length() < 10) {
      return false;
    }

    // 确保主要是中文内容(中文字符应占主要部分)
    int chineseCharCount = 0;
    int totalCharCount = 0;

    for (char c : content.toCharArray()) {
      // 忽略空白字符
      if (Character.isWhitespace(c)) {
        continue;
      }

      totalCharCount++;
      if (Character.UnicodeBlock.of(c) == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS) {
        chineseCharCount++;
      }
    }

    // 如果内容太短，直接通过验证
    if (totalCharCount < 20) {
      return true;
    }

    // 考虑到口语化表达可能包含更多标点符号，降低中文字符比例要求
    double chineseRatio = (double) chineseCharCount / totalCharCount;
    boolean hasEnoughChinese = chineseRatio >= 0.5; // 至少50%是中文字符

    return hasEnoughChinese;
  }

  /**
   * 判断美化后的内容长度是否合理
   * 对于较短的原文，不应该有过度扩展
   */
  private boolean isLengthReasonable(String original, String beautified) {
    if (original == null || beautified == null) {
      return false;
    }

    int originalLength = original.length();
    int beautifiedLength = beautified.length();

    // 计算长度比例
    double ratio = (double) beautifiedLength / originalLength;

    // 短文本(<=50字符)的允许扩展比例更严格
    if (originalLength <= 50) {
      return ratio <= 1.5; // 不允许扩展超过50%
    }

    // 中等长度文本(51-200字符)
    if (originalLength <= 200) {
      return ratio <= 1.3; // 不允许扩展超过30%
    }

    // 长文本(>200字符)
    return ratio <= 1.2; // 不允许扩展超过20%
  }
}
